home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / INTERNET / SITES / LITTLE / P3SRC.ZIP / ATARI / COLOUR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  10.5 KB  |  629 lines
  1. /****************************************************************************
  2. *                   colour.c
  3. *
  4. *  This module implements routines to manipulate colours.
  5. *
  6. *  from Persistence of Vision(tm) Ray Tracer
  7. *  Copyright 1996 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  NOTICE: This source code file is provided so that users may experiment
  10. *  with enhancements to POV-Ray and to port the software to platforms other 
  11. *  than those supported by the POV-Ray Team.  There are strict rules under
  12. *  which you are permitted to use this file.  The rules are in the file
  13. *  named POVLEGAL.DOC which should be distributed with this file. If 
  14. *  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  15. *  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  16. *  Forum.  The latest version of POV-Ray may be found there as well.
  17. *
  18. * This program is based on the popular DKB raytracer version 2.12.
  19. * DKBTrace was originally written by David K. Buck.
  20. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21. *
  22. *****************************************************************************/
  23.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27. #include "colour.h"
  28. #include "pigment.h"
  29. #include "normal.h"
  30. #include "texture.h"
  31.  
  32.  
  33. /*****************************************************************************
  34. * Local preprocessor defines
  35. ******************************************************************************/
  36.  
  37.  
  38.  
  39. /*****************************************************************************
  40. * Local typedefs
  41. ******************************************************************************/
  42.  
  43.  
  44.  
  45. /*****************************************************************************
  46. * Local variables
  47. ******************************************************************************/
  48.  
  49.  
  50. /*****************************************************************************
  51. * Static functions
  52. ******************************************************************************/
  53.  
  54.  
  55.  
  56. /*****************************************************************************
  57. *
  58. * FUNCTION
  59. *
  60. * INPUT
  61. *   
  62. * OUTPUT
  63. *   
  64. * RETURNS
  65. *   
  66. * AUTHOR
  67. *
  68. *   POV-Ray Team
  69. *   
  70. * DESCRIPTION
  71. *
  72. *   -
  73. *
  74. * CHANGES
  75. *
  76. *   -
  77. *
  78. ******************************************************************************/
  79.  
  80. COLOUR *Create_Colour ()
  81. {
  82.   COLOUR *New;
  83.  
  84.   New = (COLOUR *)POV_MALLOC(sizeof (COLOUR), "color");
  85.  
  86.   Make_Colour (*New, 0.0, 0.0, 0.0);
  87.  
  88.   return (New);
  89. }
  90.  
  91.  
  92.  
  93. /*****************************************************************************
  94. *
  95. * FUNCTION
  96. *
  97. * INPUT
  98. *   
  99. * OUTPUT
  100. *   
  101. * RETURNS
  102. *   
  103. * AUTHOR
  104. *
  105. *   POV-Ray Team
  106. *   
  107. * DESCRIPTION
  108. *
  109. *   -
  110. *
  111. * CHANGES
  112. *
  113. *   -
  114. *
  115. ******************************************************************************/
  116.  
  117. COLOUR *Copy_Colour (Old)
  118. COLOUR Old;
  119. {
  120.   COLOUR *New;
  121.  
  122.   if (Old != NULL)
  123.   {
  124.     New = Create_Colour ();
  125.  
  126.     Assign_Colour(*New,Old);
  127.   }
  128.   else
  129.   {
  130.     New = NULL;
  131.   }
  132.  
  133.   return (New);
  134. }
  135.  
  136.  
  137.  
  138. /*****************************************************************************
  139. *
  140. * FUNCTION
  141. *
  142. * INPUT
  143. *   
  144. * OUTPUT
  145. *   
  146. * RETURNS
  147. *   
  148. * AUTHOR
  149. *
  150. *   POV-Ray Team
  151. *   
  152. * DESCRIPTION
  153. *
  154. *   -
  155. *
  156. * CHANGES
  157. *
  158. *   Aug 1995 : Use POV_CALLOC to initialize entries. [DB]
  159. *
  160. ******************************************************************************/
  161.  
  162. BLEND_MAP_ENTRY *Create_BMap_Entries (Map_Size)
  163. int Map_Size;
  164. {
  165.   BLEND_MAP_ENTRY *New;
  166.  
  167.   New = (BLEND_MAP_ENTRY *)POV_CALLOC((size_t)Map_Size, sizeof (BLEND_MAP_ENTRY), "blend map entry");
  168.  
  169.   return (New);
  170. }
  171.  
  172.  
  173.  
  174. /*****************************************************************************
  175. *
  176. * FUNCTION
  177. *
  178. * INPUT
  179. *   
  180. * OUTPUT
  181. *   
  182. * RETURNS
  183. *   
  184. * AUTHOR
  185. *
  186. *   POV-Ray Team
  187. *   
  188. * DESCRIPTION
  189. *
  190. *
  191. * CHANGES
  192. *
  193. ******************************************************************************/
  194.  
  195. BLEND_MAP_ENTRY *Copy_BMap_Entries (Old, Map_Size, Type)
  196. BLEND_MAP_ENTRY *Old;
  197. int Map_Size, Type;
  198. {
  199.   int i;
  200.   BLEND_MAP_ENTRY *New;
  201.  
  202.   if (Old != NULL)
  203.   {
  204.     New = Create_BMap_Entries (Map_Size);
  205.  
  206.     for (i = 0; i < Map_Size; i++)
  207.     {
  208.       switch (Type)
  209.       {
  210.         case PIGMENT_TYPE:
  211.  
  212.           New[i].Vals.Pigment = Copy_Pigment(Old[i].Vals.Pigment);
  213.  
  214.           break;
  215.  
  216.         case NORMAL_TYPE:
  217.  
  218.           New[i].Vals.Tnormal = Copy_Tnormal(Old[i].Vals.Tnormal);
  219.  
  220.           break;
  221.  
  222.         case TEXTURE_TYPE:
  223.  
  224.           New[i].Vals.Texture = Copy_Textures(Old[i].Vals.Texture);
  225.  
  226.           break;
  227.  
  228.         case COLOUR_TYPE:
  229.         case SLOPE_TYPE:
  230.  
  231.           New[i] = Old[i];
  232.  
  233.           break;
  234.       }
  235.     }
  236.   }
  237.   else
  238.   {
  239.     New = NULL;
  240.   }
  241.  
  242.   return (New);
  243. }
  244.  
  245.  
  246.  
  247. /*****************************************************************************
  248. *
  249. * FUNCTION
  250. *
  251. *   Create_Blend_Map
  252. *
  253. * INPUT
  254. *   
  255. * OUTPUT
  256. *   
  257. * RETURNS
  258. *   
  259. * AUTHOR
  260. *
  261. *   POV-Ray Team
  262. *   
  263. * DESCRIPTION
  264. *
  265. *   -
  266. *
  267. * CHANGES
  268. *
  269. *   -
  270. *
  271. ******************************************************************************/
  272.  
  273. BLEND_MAP *Create_Blend_Map ()
  274. {
  275.   BLEND_MAP *New;
  276.  
  277.   New = (BLEND_MAP *)POV_MALLOC(sizeof (BLEND_MAP), "blend map");
  278.  
  279.   New->Users = 1;
  280.  
  281.   New->Number_Of_Entries = 0;
  282.  
  283.   New->Type = COLOUR_TYPE;
  284.  
  285.   New->Blend_Map_Entries = NULL;
  286.  
  287.   New->Transparency_Flag = FALSE;
  288.  
  289.   return (New);
  290. }
  291.  
  292.  
  293.  
  294. /*****************************************************************************
  295. *
  296. * FUNCTION
  297. *
  298. *   Copy_Blend_Map
  299. *
  300. * INPUT
  301. *   
  302. * OUTPUT
  303. *
  304. * RETURNS
  305. *   
  306. * AUTHOR
  307. *
  308. *   POV-Ray Team
  309. *   
  310. * DESCRIPTION
  311. *
  312. *   -
  313. *
  314. * CHANGES
  315. *
  316. *   -
  317. *
  318. ******************************************************************************/
  319.  
  320. BLEND_MAP *Copy_Blend_Map (Old)
  321. BLEND_MAP *Old;
  322. {
  323.   BLEND_MAP *New;
  324.  
  325.   New = Old;
  326.  
  327.   /* 
  328.    * Do not increase the users field if it is negative.
  329.    *
  330.    * A negative users field incicates a reference to a static
  331.    * or global memory area in the data segment, not on the heap!
  332.    * Thus it must not be deleted later.
  333.    */
  334.  
  335.   if ((New != NULL) && (New->Users >= 0))
  336.   {
  337.     New->Users++;
  338.   }
  339.  
  340.   return (New);
  341. }
  342.  
  343.  
  344.  
  345. /*****************************************************************************
  346. *
  347. * FUNCTION
  348. *
  349. *   Colour_Distance
  350. *
  351. * INPUT
  352. *
  353. * OUTPUT
  354. *
  355. * RETURNS
  356. *
  357. * AUTHOR
  358. *
  359. *   POV-Ray Team
  360. *
  361. * DESCRIPTION
  362. *
  363. *   -
  364. *
  365. * CHANGES
  366. *
  367. *   -
  368. *
  369. ******************************************************************************/
  370.  
  371. DBL Colour_Distance (colour1, colour2)
  372. COLOUR colour1, colour2;
  373. {
  374.   return (fabs(colour1[RED]   - colour2[RED]) +
  375.           fabs(colour1[GREEN] - colour2[GREEN]) +
  376.           fabs(colour1[BLUE]  - colour2[BLUE]));
  377. }
  378.  
  379.  
  380.  
  381. /*****************************************************************************
  382. *
  383. * FUNCTION
  384. *
  385. *   Add_Colour
  386. *
  387. * INPUT
  388. *   
  389. * OUTPUT
  390. *   
  391. * RETURNS
  392. *   
  393. * AUTHOR
  394. *
  395. *   POV-Ray Team
  396. *   
  397. * DESCRIPTION
  398. *
  399. *   -
  400. *
  401. * CHANGES
  402. *
  403. *   -
  404. *
  405. ******************************************************************************/
  406.  
  407. void Add_Colour (result, colour1, colour2)
  408. COLOUR result, colour1, colour2;
  409. {
  410.   result[RED]    = colour1[RED]    + colour2[RED];
  411.   result[GREEN]  = colour1[GREEN]  + colour2[GREEN];
  412.   result[BLUE]   = colour1[BLUE]   + colour2[BLUE];
  413.   result[FILTER] = colour1[FILTER] + colour2[FILTER];
  414.   result[TRANSM] = colour1[TRANSM] + colour2[TRANSM];
  415. }
  416.  
  417.  
  418.  
  419. /*****************************************************************************
  420. *
  421. * FUNCTION
  422. *
  423. *   Scale_Colour
  424. *
  425. * INPUT
  426. *   
  427. * OUTPUT
  428. *   
  429. * RETURNS
  430. *   
  431. * AUTHOR
  432. *
  433. *   POV-Ray Team
  434. *   
  435. * DESCRIPTION
  436. *
  437. *   -
  438. *
  439. * CHANGES
  440. *
  441. *   -
  442. *
  443. ******************************************************************************/
  444.  
  445. void Scale_Colour (result, colour, factor)
  446. COLOUR result, colour;
  447. DBL factor;
  448. {
  449.   result[RED]    = colour[RED]    * factor;
  450.   result[GREEN]  = colour[GREEN]  * factor;
  451.   result[BLUE]   = colour[BLUE]   * factor;
  452.   result[FILTER] = colour[FILTER] * factor;
  453.   result[TRANSM] = colour[TRANSM] * factor;
  454. }
  455.  
  456.  
  457.  
  458. /*****************************************************************************
  459. *
  460. * FUNCTION
  461. *
  462. *   Clip_Colour
  463. *
  464. * INPUT
  465. *   
  466. * OUTPUT
  467. *   
  468. * RETURNS
  469. *   
  470. * AUTHOR
  471. *
  472. *   POV-Ray Team
  473. *   
  474. * DESCRIPTION
  475. *
  476. *   -
  477. *
  478. * CHANGES
  479. *
  480. *   -
  481. *
  482. ******************************************************************************/
  483.  
  484. void Clip_Colour (result, colour)
  485. COLOUR result, colour;
  486. {
  487.   if (colour[RED] > 1.0)
  488.   {
  489.     result[RED] = 1.0;
  490.   }
  491.   else
  492.   {
  493.     if (colour[RED] < 0.0)
  494.     {
  495.       result[RED] = 0.0;
  496.     }
  497.     else
  498.     {
  499.       result[RED] = colour[RED];
  500.     }
  501.   }
  502.  
  503.   if (colour[GREEN] > 1.0)
  504.   {
  505.     result[GREEN] = 1.0;
  506.   }
  507.   else
  508.   {
  509.     if (colour[GREEN] < 0.0)
  510.     {
  511.       result[GREEN] = 0.0;
  512.     }
  513.     else
  514.     {
  515.       result[GREEN] = colour[GREEN];
  516.     }
  517.   }
  518.  
  519.   if (colour[BLUE] > 1.0)
  520.   {
  521.     result[BLUE] = 1.0;
  522.   }
  523.   else
  524.   {
  525.     if (colour[BLUE] < 0.0)
  526.     {
  527.       result[BLUE] = 0.0;
  528.     }
  529.     else
  530.     {
  531.       result[BLUE] = colour[BLUE];
  532.     }
  533.   }
  534.  
  535.   if (colour[FILTER] > 1.0)
  536.   {
  537.     result[FILTER] = 1.0;
  538.   }
  539.   else
  540.   {
  541.     if (colour[FILTER] < 0.0)
  542.     {
  543.       result[FILTER] = 0.0;
  544.     }
  545.     else
  546.     {
  547.       result[FILTER] = colour[FILTER];
  548.     }
  549.   }
  550.  
  551.   if (colour[TRANSM] > 1.0)
  552.   {
  553.     result[TRANSM] = 1.0;
  554.   }
  555.   else
  556.   {
  557.     if (colour[TRANSM] < 0.0)
  558.     {
  559.       result[TRANSM] = 0.0;
  560.     }
  561.     else
  562.     {
  563.       result[TRANSM] = colour[TRANSM];
  564.     }
  565.   }
  566. }
  567.  
  568.  
  569.  
  570. /*****************************************************************************
  571. *
  572. * FUNCTION
  573. *
  574. *   Destroy_Blend_Map
  575. *
  576. * INPUT
  577. *   
  578. * OUTPUT
  579. *   
  580. * RETURNS
  581. *   
  582. * AUTHOR
  583. *
  584. *   POV-Ray Team
  585. *   
  586. * DESCRIPTION
  587. *
  588. *   -
  589. *
  590. * CHANGES
  591. *
  592. *   -
  593. *
  594. ******************************************************************************/
  595.  
  596. void Destroy_Blend_Map (BMap)
  597. BLEND_MAP *BMap;
  598. {
  599.   int i;
  600.   
  601.   if (BMap != NULL)
  602.   {
  603.     if (--(BMap->Users) == 0)
  604.     {
  605.       for (i = 0; i < BMap->Number_Of_Entries; i++)
  606.       {
  607.         switch (BMap->Type)
  608.         {
  609.            case PIGMENT_TYPE:
  610.              Destroy_Pigment(BMap->Blend_Map_Entries[i].Vals.Pigment);
  611.              break;
  612.  
  613.            case NORMAL_TYPE:
  614.              Destroy_Tnormal(BMap->Blend_Map_Entries[i].Vals.Tnormal);
  615.              break;
  616.  
  617.            case TEXTURE_TYPE:
  618.              Destroy_Textures(BMap->Blend_Map_Entries[i].Vals.Texture);
  619.         }
  620.       }
  621.  
  622.       POV_FREE (BMap->Blend_Map_Entries);
  623.  
  624.       POV_FREE (BMap);
  625.     }
  626.   }
  627. }
  628.  
  629.